home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDX302.ST / PART.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  7.7 KB  |  397 lines
  1. /* part.c */
  2.  
  3.  
  4. /*
  5.  * 24-Nov-88    jye.     change and add codes so that can be used for MS-DOS
  6.  */
  7. #include "obdefs.h"
  8. #include "gemdefs.h"
  9. #include "osbind.h"
  10. #include "mydefs.h"
  11. #include "part.h"
  12. #include "bsl.h"
  13. #include "hdx.h"
  14. #include "addr.h"
  15.  
  16.  
  17. extern char sbuf[];
  18. extern int npart;
  19. extern int uplim;
  20. extern long bslsiz;
  21. extern long gbslsiz();
  22. extern int noinfo;        /* 1: no information inside the wincap */
  23.  
  24. /*
  25.  * Complain about partition error.
  26.  *
  27.  */
  28. parterr(devno)
  29. int devno;
  30. {
  31.     char *pdev="X";
  32.     
  33.     *pdev = devno + '0';
  34.     (cantpart[PTNDEV].ob_spec)->te_ptext = pdev;
  35.     cantpart[PTNERROK].ob_state = NORMAL;
  36.     execform(cantpart);
  37.     return ERROR;
  38. }
  39.  
  40.  
  41. /*
  42.  * Fill in partition entry with default information
  43.  * and configuration values from the current "pr" wincap entry.
  44.  *
  45.  */
  46. fillpart(n, part)
  47. int n;
  48. PART *part;
  49. {
  50.     long num;
  51.     char *partid;
  52.     char *idstr = "XX";
  53.     char *wgetstr();
  54.  
  55.     idstr[1] = n + '0';
  56.  
  57.     /* see if `pX' is mentioned */
  58.     *idstr = 'p';
  59.     if (wgetnum(idstr, &num) == OK)
  60.     {
  61.     /* do the ST partition assignment */
  62.         npart++;
  63.         part->p_siz = (LONG)(num / 512);
  64.            part->p_flg = P_EXISTS;
  65.         if (part->p_siz < MB16)    {
  66.             part->p_id[0] = 'G';
  67.             part->p_id[1] = 'E';
  68.             part->p_id[2] = 'M';
  69.         } else {
  70.             part->p_id[0] = 'B';
  71.             part->p_id[1] = 'G';
  72.             part->p_id[2] = 'M';
  73.         }
  74.     }
  75. }
  76.  
  77.  
  78. /* set the partition informations to the partition structures */
  79.  
  80. setpart(part, pnam, hsize)
  81. PART *part;
  82. char *pnam;
  83. long hsize;
  84. {
  85.     long onepart, remain;
  86.     int i;
  87.  
  88.     npart = 4;
  89.     if ((!noinfo) && (*pnam))     {
  90.         /* there is a partition scheme inside the wincap */
  91.         msetpart(part, pnam, hsize);
  92.         return OK;
  93.     }
  94.     onepart = hsize/4;
  95.     remain = (hsize - onepart * 4) / 4;
  96.     for ( i = 0; i < 4; i++, part++)    {
  97.         if (i == 4)    {
  98.             part->p_siz = hsize - (onepart + remain) * 3;
  99.         } else {
  100.             part->p_siz = onepart+remain;
  101.         }
  102.            part->p_flg = P_EXISTS;
  103.         if (part->p_siz < MB16)    {
  104.                part->p_id[0] = 'G';
  105.                part->p_id[1] = 'E';
  106.                part->p_id[2] = 'M';
  107.         } else {
  108.                part->p_id[0] = 'B';
  109.                part->p_id[1] = 'G';
  110.                part->p_id[2] = 'M';
  111.         }
  112.     }
  113. }
  114.  
  115. /* set the partition informations from the 'pname'.     */
  116. /* For example, pname = 12-12-14-14                        */        
  117.  
  118. msetpart(part, pname, hsize)
  119. PART *part;
  120. char *pname;
  121. long hsize;
  122. {
  123.     long part1, part2, part3, part4, remain;
  124.     int i, np;
  125.  
  126.     npart = 4;
  127.     np = 4;
  128.     convs2i(pname, &part1, 1);        /* 1: get first ASCII */
  129.     if (convs2i(pname, &part2, 2) == 1)        {        /* 2: get second ASCII */
  130.         /* only one partition */
  131.         part2 = 0;
  132.         part3 = 0;
  133.         part4 = 0;
  134.         np = 1;
  135.     } else if (convs2i(pname, &part3, 3) == 2)    {    /* 3: get third ASCII */
  136.         /* only two partitions */
  137.         part3 = 0;
  138.         part4 = 0;
  139.         np = 2;
  140.     } else if (convs2i(pname, &part4, 4) == 3)    {    /* 4: get fourth ASCII */
  141.         /* only three partitions */
  142.         part4 = 0;
  143.         np = 3;
  144.     }
  145.     remain = (hsize - (part1 + part2 + part3 + part4)) / np;
  146.     if (np == 1)    {
  147.         part1 = hsize;
  148.     } else if (np == 2)    {
  149.         part1 += remain;
  150.         part2 = hsize - part1;
  151.     } else if (np == 3)    {
  152.         part1 += remain;
  153.         part2 += remain;
  154.         part3 = hsize - part1 - part2;
  155.     } else {
  156.         part1 += remain;
  157.         part2 += remain;
  158.         part3 += remain;
  159.         part4 = hsize - part1 - part2 - part3;
  160.     }
  161.     for ( i = 0; i < 4; i++, part++)    {
  162.         switch(i)    {
  163.             case 0:    part->p_siz = part1;
  164.                     break;
  165.             case 1:    part->p_siz = part2;
  166.                     break;
  167.             case 2:    part->p_siz = part3;
  168.                     break;
  169.             case 3:    part->p_siz = part4;
  170.                     break;
  171.         }
  172.         if (!part->p_siz) continue;
  173.            part->p_flg = P_EXISTS;
  174.         if (part->p_siz < MB16)    {
  175.                part->p_id[0] = 'G';
  176.                part->p_id[1] = 'E';
  177.                part->p_id[2] = 'M';
  178.         } else {
  179.                part->p_id[0] = 'B';
  180.                part->p_id[1] = 'G';
  181.                part->p_id[2] = 'M';
  182.         }
  183.     }
  184. }
  185.  
  186.  
  187. /* conver the string 12-12-14-14 to a integer */
  188.  
  189. convs2i(pname, num, flag)
  190.  
  191. char *pname;
  192. long *num;
  193. int flag;        /* 1: conver the first one. 3: conver the third one */
  194.  
  195. {
  196.     char tem[10], *ptr;
  197.     int i;
  198.     UWORD n=0;
  199.  
  200.     ptr = pname;
  201.     for (i = 0; i < 10; i++)
  202.         tem[i] = "\0";
  203.  
  204.     if (flag == 2)    {    /* conver the second one of pname */
  205.         while ((*ptr != '-') && (*ptr))      ptr++;
  206.         if (!*ptr)  return 1;    /* only one partition */
  207.         ptr++;
  208.     } else if (flag == 3)    {    /* conver the third one of 12-12-14-14 */
  209.         while (*ptr != '-')     ptr++;
  210.         ptr++;
  211.         while ((*ptr != '-') && (*ptr))      ptr++;
  212.         if (!*ptr) return 2;        /* only two partitions */
  213.         ptr++;
  214.     } else if (flag == 4)    {
  215.         while (*ptr != '-')     ptr++;
  216.         ptr++;
  217.         while (*ptr != '-')     ptr++;
  218.         ptr++;
  219.         while ((*ptr != '-') && (*ptr))      ptr++;
  220.         if (!*ptr) return 3;        /* only three partitions */
  221.         ptr++;
  222.     }
  223.     /* copy the string into the buf */
  224.     for (i = 0; (*ptr != '-')&&(*ptr); )    {
  225.         tem[i++] = *ptr++;
  226.     }
  227.  
  228.     /* conver the string to integer */
  229.     for (i = 0; tem[i] >= '0' && tem[i] <= '9'; ++i)
  230.         n = 10 * n + (UWORD)(tem[i] - '0');
  231.  
  232.     *num = (long)n * 2048;
  233.     if (!n) return(flag - 1);
  234.     return OK;
  235. }
  236.  
  237.  
  238.  
  239. /* set the menu partition scheme */
  240.  
  241. setschm(dsize, partnames)
  242.  
  243. long dsize;
  244. char *partnames;
  245.  
  246. {
  247.     int part12;
  248.     int part34;
  249.     int i;
  250.  
  251.     for (i = 0; i < NAMSIZ; i++)    {
  252.         partnames[i] = '\0';
  253.     }
  254.     part34 = dsize/(2048*4) - 2;
  255.     part12 = part34 + 4;
  256.     for (i = 0; i < 4; i++)    {
  257.         if (!part34)        /* add the remainder into part12 */
  258.             part12 += (dsize/2048 - 2 * part12) / 2;
  259.         itoas(partnames, part12, 0);
  260.         itoas(partnames, part34, 1);
  261.         if (part34 == 1)    {        
  262.             part12++;         /* add the remainder into part12 */
  263.             part34 = 0;
  264.         } else {
  265.             part34 -= 2;
  266.             part12 += 2;
  267.         }
  268.         if (part34 < 0) break;
  269.     }
  270. }
  271.  
  272.  
  273. /* convert the integer into ASCII and store it into a buffer like    */
  274. /* 12-12 if the integer is 12                                         */
  275.  
  276. itoas(buf, num, flag)
  277. char *buf;
  278. int num;
  279. int flag;         /* 1: put second part of scheme. Now buf = 12-12\0 */
  280.  
  281. {
  282.     int i=0, j;
  283.     char tem[10];
  284.  
  285.     if (*buf)    { /* 12-12-14-14\010-10\0 inside the buf */
  286.     skp:
  287.         while (*buf)    buf++;
  288.         if ((!flag) || (*(buf+1)))     buf++;        /* skip between string */
  289.         if (*buf)     {
  290.             goto skp;
  291.         }
  292.         if (flag)    {    /* put second part of scheme */ 
  293.             *buf++ = '-';
  294.         }
  295.     } 
  296.     /* conver the integer to ASCII */
  297.     do    {    /* generate digits in reverse order */
  298.         tem[i++] = num % 10 + '0';        /* get next digits */
  299.     } while ((num /= 10) > 0);            /* delete it */
  300.  
  301.     j = i;
  302.     for (; i > 0; )    {    /* reverse string 'buf' in place */
  303.         *buf++ = tem[--i];
  304.     }
  305.     *buf++ = '-';
  306.     for (; j > 0; )    {    /* reverse string 'buf' in place */
  307.         *buf++ = tem[--j];
  308.     }
  309.     *buf++ = '\0';
  310. }
  311.  
  312.  
  313. /*
  314.  * Force checksum of sector image to a value
  315.  */
  316. forcesum(image, sum)
  317. UWORD *image;
  318. UWORD sum;
  319. {
  320.     register int i;
  321.     register UWORD w;
  322.  
  323.     w = 0;
  324.     /* up limit is half of buffer size - 2 */
  325.     for (i = 0; i < ((UWORD)BPS/2 - 1); ++i)
  326.     w += *image++;
  327.     *image++ = sum - w;
  328. }
  329.  
  330.  
  331. /*
  332.  * Put word in memory in 8086 byte-reversed format.
  333.  *
  334.  */
  335. iw(wp, w)
  336. UWORD *wp;
  337. UWORD w;
  338. {
  339.     char *p;
  340.  
  341.     p = (char *)wp;
  342.     p[0] = (w & 0xff);
  343.     p[1] = ((w >> 8) & 0xff);
  344. }
  345.  
  346. /*
  347.  * Put long word in memory in 8086 word-reversed format.
  348.  *
  349.  */
  350. ilong(lp, l)
  351. long *lp;
  352. long l;
  353. {
  354.     UWORD *p;
  355.  
  356.     p = (UWORD *)lp;
  357.     iw(&p[0],(UWORD)(l & 0xffff));
  358.     iw(&p[1],(UWORD)((l >> 16) & 0xffff));
  359. }
  360.  
  361. /*
  362.  * Get long word in memory, from 8086 word-reversed format.
  363.  *
  364.  */
  365. glong(al, lp)   /* al is a swaped return long word,*/
  366.                 /* lp is a to be swaped long word */
  367. long *al;
  368. long *lp;
  369.  
  370. {
  371.    char *p, *q;
  372.  
  373.     p = (char *)al;
  374.     q = (char *)lp;
  375.     p[0] = q[3];
  376.     p[1] = q[2];
  377.     p[2] = q[1];
  378.     p[3] = q[0];
  379. }
  380.  
  381. /*
  382.  * Get word in memory, from 8086 byte-reversed format.
  383.  *
  384.  */
  385. UWORD gw(wp, aw)
  386. UWORD *wp;
  387. UWORD *aw;
  388. {
  389.     char *p, *q;
  390.  
  391.     p = (char *)wp;
  392.     q = (char *)aw;
  393.     q[0] = p[1];
  394.     q[1] = p[0];
  395.     return *aw;
  396. }
  397.